package com.warom.sdg.webview.jsinterface;

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.webkit.JavascriptInterface;

import com.google.gson.Gson;
import com.warom.sdg.config.MeasurementPoint;
import com.warom.sdg.config.PlcMeasurementConfig;
import com.warom.sdg.enums.ModuleType;
import com.warom.sdg.model.ApiResponse;
import com.warom.sdg.model.DeviceType;
import com.warom.sdg.webview.BaseWebViewJsInterface;
import com.warom.sdg.webview.WebViewWrapper;

import org.json.JSONObject;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;

/**
 * 其他模块专用WebViewJsInterface
 * 提供其他模块页面所需的JavaScript接口，如照明回路、移动风机等
 */
public class WebViewJsOtherModuleInterface extends BaseWebViewJsInterface {
    private static final String TAG = "OtherModuleJsInterface";
    private final Handler mHandler = new Handler(Looper.getMainLooper());
    private final Gson gson = new Gson();
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    private WebViewWrapper webViewWrapper;

    /**
     * 构造函数
     * @param context 上下文
     */
    public WebViewJsOtherModuleInterface(Context context) {
        super(context, null);
    }

    /**
     * 构造函数
     * @param context 上下文
     * @param webViewWrapper WebView包装器
     */
    public WebViewJsOtherModuleInterface(Context context, WebViewWrapper webViewWrapper) {
        super(context, webViewWrapper);
        this.webViewWrapper = webViewWrapper;
    }

    /**
     * 异步获取其他模块数据
     * @param args 参数
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void getOtherDataAsync(String args, String requestId) {
        executor.execute(() -> getOtherData(args, result -> handleAsyncResponse(requestId, result)));
    }

    /**
     * 获取其他模块数据
     * @param argsJson 参数JSON
     * @param callback 回调函数
     */
    private void getOtherData(String argsJson, Consumer<String> callback) {
        try {
            // 解析参数
            // JSONObject argsObj = new JSONObject(argsJson);
            // int moduleTypeId = argsObj.optInt("moduleTypeId", 4); // 默认为OTHER模块
            // int deviceId = argsObj.optInt("deviceId", 1); // 默认为设备ID 1
            
            // 获取OTHER模块对应的设备-测点映射
            Map<DeviceType, List<MeasurementPoint>> otherMap =
                PlcMeasurementConfig.moduleDevicePointsMap.get(ModuleType.OTHER);
            
            // 如果映射为空，返回空列表
            if (otherMap == null || otherMap.isEmpty()) {
                Log.w(TAG, "OTHER模块映射为空");
                callback.accept(gson.toJson(new ArrayList<>()));
                return;
            }
            
            // 收集所有设备的测点到一个列表
            List<MeasurementPoint> allPoints = new ArrayList<>();
            for (List<MeasurementPoint> devicePoints : otherMap.values()) {
                if (devicePoints != null && !devicePoints.isEmpty()) {
                    allPoints.addAll(devicePoints);
                }
            }
            
            // 为每个测点设置随机值（模拟数据）
            // for (PlcMeasurementConfig.MeasurementPoint point : allPoints) {
            //     // 如果是状态型测点，设置0或1
            //     if (point.isStatusPoint()) {
            //         point.setValue(Math.random() > 0.5 ? 1 : 0);
            //     } else {
            //         // 如果是数值型测点，设置范围内的随机值
            //         double min = point.getMinValue();
            //         double max = point.getMaxValue();
            //         point.setValue(min + Math.random() * (max - min));
            //     }
            // }
            
            // 返回所有测点的JSON
            callback.accept(gson.toJson(allPoints));
            
        } catch (Exception e) {
            Log.e(TAG, "获取OTHER模块数据失败", e);
            callback.accept("[]");
        }
    }

    /**
     * 异步控制设备
     * @param args 参数
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void controlOtherDeviceAsync(String args, String requestId) {
        executor.execute(() -> controlOtherDevice(args, result -> handleAsyncResponse(requestId, result)));
    }

    /**
     * 控制设备
     * @param argsJson 参数JSON
     * @param callback 回调函数
     */
    private void controlOtherDevice(String argsJson, Consumer<String> callback) {
        try {
            // 解析参数
            JSONObject argsObj = new JSONObject(argsJson);
            int moduleTypeId = argsObj.optInt("moduleTypeId", 4); // 默认为OTHER模块
            int deviceTypeId = argsObj.optInt("deviceTypeId", 1); // 默认为SIEMENS_S7设备
            int deviceId = argsObj.optInt("deviceId", 1); // 默认为设备ID 1
            String address = argsObj.optString("address", ""); // 测点地址
            double value = argsObj.optDouble("value", 0); // 控制值
            
            // 创建成功响应
            ApiResponse<String> response = new ApiResponse<>();
            response.setSuccess(true);
            response.setMessage("控制设备成功");
            response.setData("操作已执行");
            
            // 返回成功响应
            callback.accept(gson.toJson(response));
            
        } catch (Exception e) {
            Log.e(TAG, "控制OTHER模块设备失败", e);
            
            // 创建失败响应
            ApiResponse<String> response = new ApiResponse<>();
            response.setSuccess(false);
            response.setMessage("控制设备失败: " + e.getMessage());
            
            // 返回失败响应
            callback.accept(gson.toJson(response));
        }
    }
} 